home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Bank smakow / BankSmakow.air / BankSmakow.swf / scripts / mx / controls / scrollClasses / ScrollBar.as next >
Text File  |  2009-12-16  |  24KB  |  645 lines
  1. package mx.controls.scrollClasses
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.events.Event;
  5.    import flash.events.MouseEvent;
  6.    import flash.events.TimerEvent;
  7.    import flash.geom.Point;
  8.    import flash.ui.Keyboard;
  9.    import flash.utils.Timer;
  10.    import mx.controls.Button;
  11.    import mx.core.FlexVersion;
  12.    import mx.core.UIComponent;
  13.    import mx.core.mx_internal;
  14.    import mx.events.FlexEvent;
  15.    import mx.events.SandboxMouseEvent;
  16.    import mx.events.ScrollEvent;
  17.    import mx.events.ScrollEventDetail;
  18.    import mx.styles.ISimpleStyleClient;
  19.    import mx.styles.StyleProxy;
  20.    
  21.    use namespace mx_internal;
  22.    
  23.    public class ScrollBar extends UIComponent
  24.    {
  25.       
  26.       mx_internal static const VERSION:String = "3.5.0.12683";
  27.       
  28.       public static const THICKNESS:Number = 16;
  29.        
  30.       
  31.       private var _direction:String = "vertical";
  32.       
  33.       private var _pageScrollSize:Number = 0;
  34.       
  35.       mx_internal var scrollTrack:Button;
  36.       
  37.       mx_internal var downArrow:Button;
  38.       
  39.       mx_internal var scrollThumb:ScrollThumb;
  40.       
  41.       private var trackScrollRepeatDirection:int;
  42.       
  43.       private var _minScrollPosition:Number = 0;
  44.       
  45.       private var trackPosition:Number;
  46.       
  47.       private var _pageSize:Number = 0;
  48.       
  49.       mx_internal var _minHeight:Number = 32;
  50.       
  51.       private var _maxScrollPosition:Number = 0;
  52.       
  53.       private var trackScrollTimer:Timer;
  54.       
  55.       mx_internal var upArrow:Button;
  56.       
  57.       private var _lineScrollSize:Number = 1;
  58.       
  59.       private var _scrollPosition:Number = 0;
  60.       
  61.       private var trackScrolling:Boolean = false;
  62.       
  63.       mx_internal var isScrolling:Boolean;
  64.       
  65.       mx_internal var oldPosition:Number;
  66.       
  67.       mx_internal var _minWidth:Number = 16;
  68.       
  69.       public function ScrollBar()
  70.       {
  71.          super();
  72.       }
  73.       
  74.       override public function set enabled(param1:Boolean) : void
  75.       {
  76.          super.enabled = param1;
  77.          invalidateDisplayList();
  78.       }
  79.       
  80.       public function set lineScrollSize(param1:Number) : void
  81.       {
  82.          _lineScrollSize = param1;
  83.       }
  84.       
  85.       public function get minScrollPosition() : Number
  86.       {
  87.          return _minScrollPosition;
  88.       }
  89.       
  90.       mx_internal function dispatchScrollEvent(param1:Number, param2:String) : void
  91.       {
  92.          var _loc3_:ScrollEvent = new ScrollEvent(ScrollEvent.SCROLL);
  93.          _loc3_.detail = param2;
  94.          _loc3_.position = scrollPosition;
  95.          _loc3_.delta = scrollPosition - param1;
  96.          _loc3_.direction = direction;
  97.          dispatchEvent(_loc3_);
  98.       }
  99.       
  100.       private function downArrow_buttonDownHandler(param1:FlexEvent) : void
  101.       {
  102.          if(isNaN(mx_internal::oldPosition))
  103.          {
  104.             oldPosition = scrollPosition;
  105.          }
  106.          lineScroll(1);
  107.       }
  108.       
  109.       private function scrollTrack_mouseDownHandler(param1:MouseEvent) : void
  110.       {
  111.          if(!(param1.target == this || param1.target == mx_internal::scrollTrack))
  112.          {
  113.             return;
  114.          }
  115.          trackScrolling = true;
  116.          var _loc2_:DisplayObject = systemManager.getSandboxRoot();
  117.          _loc2_.addEventListener(MouseEvent.MOUSE_UP,scrollTrack_mouseUpHandler,true);
  118.          _loc2_.addEventListener(MouseEvent.MOUSE_MOVE,scrollTrack_mouseMoveHandler,true);
  119.          _loc2_.addEventListener(SandboxMouseEvent.MOUSE_UP_SOMEWHERE,scrollTrack_mouseLeaveHandler);
  120.          systemManager.deployMouseShields(true);
  121.          var _loc3_:Point = new Point(param1.localX,param1.localY);
  122.          _loc3_ = param1.target.localToGlobal(_loc3_);
  123.          _loc3_ = globalToLocal(_loc3_);
  124.          trackPosition = _loc3_.y;
  125.          if(isNaN(mx_internal::oldPosition))
  126.          {
  127.             oldPosition = scrollPosition;
  128.          }
  129.          trackScrollRepeatDirection = mx_internal::scrollThumb.y + mx_internal::scrollThumb.height < _loc3_.y ? 1 : (mx_internal::scrollThumb.y > _loc3_.y ? -1 : 0);
  130.          pageScroll(trackScrollRepeatDirection);
  131.          if(!trackScrollTimer)
  132.          {
  133.             trackScrollTimer = new Timer(getStyle("repeatDelay"),1);
  134.             trackScrollTimer.addEventListener(TimerEvent.TIMER,trackScrollTimerHandler);
  135.          }
  136.          else
  137.          {
  138.             trackScrollTimer.delay = getStyle("repeatDelay");
  139.             trackScrollTimer.repeatCount = 1;
  140.          }
  141.          trackScrollTimer.start();
  142.       }
  143.       
  144.       public function set minScrollPosition(param1:Number) : void
  145.       {
  146.          _minScrollPosition = param1;
  147.          invalidateDisplayList();
  148.       }
  149.       
  150.       public function get scrollPosition() : Number
  151.       {
  152.          return _scrollPosition;
  153.       }
  154.       
  155.       mx_internal function get linePlusDetail() : String
  156.       {
  157.          return direction == ScrollBarDirection.VERTICAL ? ScrollEventDetail.LINE_DOWN : ScrollEventDetail.LINE_RIGHT;
  158.       }
  159.       
  160.       public function get maxScrollPosition() : Number
  161.       {
  162.          return _maxScrollPosition;
  163.       }
  164.       
  165.       protected function get thumbStyleFilters() : Object
  166.       {
  167.          return null;
  168.       }
  169.       
  170.       override public function set doubleClickEnabled(param1:Boolean) : void
  171.       {
  172.       }
  173.       
  174.       public function get lineScrollSize() : Number
  175.       {
  176.          return _lineScrollSize;
  177.       }
  178.       
  179.       mx_internal function get virtualHeight() : Number
  180.       {
  181.          return unscaledHeight;
  182.       }
  183.       
  184.       public function set scrollPosition(param1:Number) : void
  185.       {
  186.          var _loc2_:Number = NaN;
  187.          var _loc3_:Number = NaN;
  188.          var _loc4_:Number = NaN;
  189.          _scrollPosition = param1;
  190.          if(mx_internal::scrollThumb)
  191.          {
  192.             if(!cacheAsBitmap)
  193.             {
  194.                cacheHeuristic = mx_internal::scrollThumb.cacheHeuristic = true;
  195.             }
  196.             if(!mx_internal::isScrolling)
  197.             {
  198.                param1 = Math.min(param1,maxScrollPosition);
  199.                param1 = Math.max(param1,minScrollPosition);
  200.                _loc2_ = maxScrollPosition - minScrollPosition;
  201.                _loc3_ = _loc2_ == 0 || isNaN(_loc2_) ? Number(0) : Number((param1 - minScrollPosition) * (trackHeight - mx_internal::scrollThumb.height) / _loc2_ + trackY);
  202.                _loc4_ = (mx_internal::virtualWidth - mx_internal::scrollThumb.width) / 2 + getStyle("thumbOffset");
  203.                mx_internal::scrollThumb.move(Math.round(_loc4_),Math.round(_loc3_));
  204.             }
  205.          }
  206.       }
  207.       
  208.       protected function get downArrowStyleFilters() : Object
  209.       {
  210.          return null;
  211.       }
  212.       
  213.       public function get pageSize() : Number
  214.       {
  215.          return _pageSize;
  216.       }
  217.       
  218.       public function set pageScrollSize(param1:Number) : void
  219.       {
  220.          _pageScrollSize = param1;
  221.       }
  222.       
  223.       public function set maxScrollPosition(param1:Number) : void
  224.       {
  225.          _maxScrollPosition = param1;
  226.          invalidateDisplayList();
  227.       }
  228.       
  229.       mx_internal function pageScroll(param1:int) : void
  230.       {
  231.          var _loc4_:Number = NaN;
  232.          var _loc5_:String = null;
  233.          var _loc2_:Number = _pageScrollSize != 0 ? Number(_pageScrollSize) : Number(pageSize);
  234.          var _loc3_:Number = _scrollPosition + param1 * _loc2_;
  235.          if(_loc3_ > maxScrollPosition)
  236.          {
  237.             _loc3_ = maxScrollPosition;
  238.          }
  239.          else if(_loc3_ < minScrollPosition)
  240.          {
  241.             _loc3_ = minScrollPosition;
  242.          }
  243.          if(_loc3_ != scrollPosition)
  244.          {
  245.             _loc4_ = scrollPosition;
  246.             scrollPosition = _loc3_;
  247.             _loc5_ = param1 < 0 ? mx_internal::pageMinusDetail : mx_internal::pagePlusDetail;
  248.             dispatchScrollEvent(_loc4_,_loc5_);
  249.          }
  250.       }
  251.       
  252.       override protected function createChildren() : void
  253.       {
  254.          super.createChildren();
  255.          if(!mx_internal::scrollTrack)
  256.          {
  257.             scrollTrack = new Button();
  258.             mx_internal::scrollTrack.focusEnabled = false;
  259.             mx_internal::scrollTrack.skinName = "trackSkin";
  260.             mx_internal::scrollTrack.upSkinName = "trackUpSkin";
  261.             mx_internal::scrollTrack.overSkinName = "trackOverSkin";
  262.             mx_internal::scrollTrack.downSkinName = "trackDownSkin";
  263.             mx_internal::scrollTrack.disabledSkinName = "trackDisabledSkin";
  264.             if(mx_internal::scrollTrack is ISimpleStyleClient)
  265.             {
  266.                ISimpleStyleClient(mx_internal::scrollTrack).styleName = this;
  267.             }
  268.             addChild(mx_internal::scrollTrack);
  269.             mx_internal::scrollTrack.validateProperties();
  270.          }
  271.          if(!mx_internal::upArrow)
  272.          {
  273.             upArrow = new Button();
  274.             mx_internal::upArrow.enabled = false;
  275.             mx_internal::upArrow.autoRepeat = true;
  276.             mx_internal::upArrow.focusEnabled = false;
  277.             mx_internal::upArrow.upSkinName = "upArrowUpSkin";
  278.             mx_internal::upArrow.overSkinName = "upArrowOverSkin";
  279.             mx_internal::upArrow.downSkinName = "upArrowDownSkin";
  280.             mx_internal::upArrow.disabledSkinName = "upArrowDisabledSkin";
  281.             mx_internal::upArrow.skinName = "upArrowSkin";
  282.             mx_internal::upArrow.upIconName = "";
  283.             mx_internal::upArrow.overIconName = "";
  284.             mx_internal::upArrow.downIconName = "";
  285.             mx_internal::upArrow.disabledIconName = "";
  286.             addChild(mx_internal::upArrow);
  287.             mx_internal::upArrow.styleName = new StyleProxy(this,upArrowStyleFilters);
  288.             mx_internal::upArrow.validateProperties();
  289.             mx_internal::upArrow.addEventListener(FlexEvent.BUTTON_DOWN,upArrow_buttonDownHandler);
  290.          }
  291.          if(!mx_internal::downArrow)
  292.          {
  293.             downArrow = new Button();
  294.             mx_internal::downArrow.enabled = false;
  295.             mx_internal::downArrow.autoRepeat = true;
  296.             mx_internal::downArrow.focusEnabled = false;
  297.             mx_internal::downArrow.upSkinName = "downArrowUpSkin";
  298.             mx_internal::downArrow.overSkinName = "downArrowOverSkin";
  299.             mx_internal::downArrow.downSkinName = "downArrowDownSkin";
  300.             mx_internal::downArrow.disabledSkinName = "downArrowDisabledSkin";
  301.             mx_internal::downArrow.skinName = "downArrowSkin";
  302.             mx_internal::downArrow.upIconName = "";
  303.             mx_internal::downArrow.overIconName = "";
  304.             mx_internal::downArrow.downIconName = "";
  305.             mx_internal::downArrow.disabledIconName = "";
  306.             addChild(mx_internal::downArrow);
  307.             mx_internal::downArrow.styleName = new StyleProxy(this,downArrowStyleFilters);
  308.             mx_internal::downArrow.validateProperties();
  309.             mx_internal::downArrow.addEventListener(FlexEvent.BUTTON_DOWN,downArrow_buttonDownHandler);
  310.          }
  311.       }
  312.       
  313.       private function scrollTrack_mouseOverHandler(param1:MouseEvent) : void
  314.       {
  315.          if(!(param1.target == this || param1.target == mx_internal::scrollTrack))
  316.          {
  317.             return;
  318.          }
  319.          if(trackScrolling)
  320.          {
  321.             trackScrollTimer.start();
  322.          }
  323.       }
  324.       
  325.       private function get minDetail() : String
  326.       {
  327.          return direction == ScrollBarDirection.VERTICAL ? ScrollEventDetail.AT_TOP : ScrollEventDetail.AT_LEFT;
  328.       }
  329.       
  330.       mx_internal function isScrollBarKey(param1:uint) : Boolean
  331.       {
  332.          var _loc2_:Number = NaN;
  333.          if(param1 == Keyboard.HOME)
  334.          {
  335.             if(scrollPosition != 0)
  336.             {
  337.                _loc2_ = scrollPosition;
  338.                scrollPosition = 0;
  339.                dispatchScrollEvent(_loc2_,minDetail);
  340.             }
  341.             return true;
  342.          }
  343.          if(param1 == Keyboard.END)
  344.          {
  345.             if(scrollPosition < maxScrollPosition)
  346.             {
  347.                _loc2_ = scrollPosition;
  348.                scrollPosition = maxScrollPosition;
  349.                dispatchScrollEvent(_loc2_,maxDetail);
  350.             }
  351.             return true;
  352.          }
  353.          return false;
  354.       }
  355.       
  356.       mx_internal function get lineMinusDetail() : String
  357.       {
  358.          return direction == ScrollBarDirection.VERTICAL ? ScrollEventDetail.LINE_UP : ScrollEventDetail.LINE_LEFT;
  359.       }
  360.       
  361.       mx_internal function get pageMinusDetail() : String
  362.       {
  363.          return direction == ScrollBarDirection.VERTICAL ? ScrollEventDetail.PAGE_UP : ScrollEventDetail.PAGE_LEFT;
  364.       }
  365.       
  366.       private function get maxDetail() : String
  367.       {
  368.          return direction == ScrollBarDirection.VERTICAL ? ScrollEventDetail.AT_BOTTOM : ScrollEventDetail.AT_RIGHT;
  369.       }
  370.       
  371.       private function scrollTrack_mouseLeaveHandler(param1:Event) : void
  372.       {
  373.          trackScrolling = false;
  374.          var _loc2_:DisplayObject = systemManager.getSandboxRoot();
  375.          _loc2_.removeEventListener(MouseEvent.MOUSE_UP,scrollTrack_mouseUpHandler,true);
  376.          _loc2_.removeEventListener(MouseEvent.MOUSE_MOVE,scrollTrack_mouseMoveHandler,true);
  377.          _loc2_.removeEventListener(SandboxMouseEvent.MOUSE_UP_SOMEWHERE,scrollTrack_mouseLeaveHandler);
  378.          systemManager.deployMouseShields(false);
  379.          if(trackScrollTimer)
  380.          {
  381.             trackScrollTimer.reset();
  382.          }
  383.          if(param1.target != mx_internal::scrollTrack)
  384.          {
  385.             return;
  386.          }
  387.          var _loc3_:String = mx_internal::oldPosition > scrollPosition ? mx_internal::pageMinusDetail : mx_internal::pagePlusDetail;
  388.          dispatchScrollEvent(mx_internal::oldPosition,_loc3_);
  389.          oldPosition = NaN;
  390.       }
  391.       
  392.       protected function get upArrowStyleFilters() : Object
  393.       {
  394.          return null;
  395.       }
  396.       
  397.       private function get trackHeight() : Number
  398.       {
  399.          return mx_internal::virtualHeight - (mx_internal::upArrow.getExplicitOrMeasuredHeight() + mx_internal::downArrow.getExplicitOrMeasuredHeight());
  400.       }
  401.       
  402.       public function get pageScrollSize() : Number
  403.       {
  404.          return _pageScrollSize;
  405.       }
  406.       
  407.       override protected function measure() : void
  408.       {
  409.          super.measure();
  410.          mx_internal::upArrow.validateSize();
  411.          mx_internal::downArrow.validateSize();
  412.          mx_internal::scrollTrack.validateSize();
  413.          if(FlexVersion.compatibilityVersion >= FlexVersion.VERSION_3_0)
  414.          {
  415.             _minWidth = !!mx_internal::scrollThumb ? Number(mx_internal::scrollThumb.getExplicitOrMeasuredWidth()) : Number(0);
  416.             _minWidth = Math.max(mx_internal::scrollTrack.getExplicitOrMeasuredWidth(),mx_internal::upArrow.getExplicitOrMeasuredWidth(),mx_internal::downArrow.getExplicitOrMeasuredWidth(),mx_internal::_minWidth);
  417.          }
  418.          else
  419.          {
  420.             _minWidth = mx_internal::upArrow.getExplicitOrMeasuredWidth();
  421.          }
  422.          _minHeight = mx_internal::upArrow.getExplicitOrMeasuredHeight() + mx_internal::downArrow.getExplicitOrMeasuredHeight();
  423.       }
  424.       
  425.       mx_internal function lineScroll(param1:int) : void
  426.       {
  427.          var _loc4_:Number = NaN;
  428.          var _loc5_:String = null;
  429.          var _loc2_:Number = _lineScrollSize;
  430.          var _loc3_:Number = _scrollPosition + param1 * _loc2_;
  431.          if(_loc3_ > maxScrollPosition)
  432.          {
  433.             _loc3_ = maxScrollPosition;
  434.          }
  435.          else if(_loc3_ < minScrollPosition)
  436.          {
  437.             _loc3_ = minScrollPosition;
  438.          }
  439.          if(_loc3_ != scrollPosition)
  440.          {
  441.             _loc4_ = scrollPosition;
  442.             scrollPosition = _loc3_;
  443.             _loc5_ = param1 < 0 ? mx_internal::lineMinusDetail : mx_internal::linePlusDetail;
  444.             dispatchScrollEvent(_loc4_,_loc5_);
  445.          }
  446.       }
  447.       
  448.       public function setScrollProperties(param1:Number, param2:Number, param3:Number, param4:Number = 0) : void
  449.       {
  450.          var _loc5_:Number = NaN;
  451.          this.pageSize = param1;
  452.          _pageScrollSize = param4 > 0 ? Number(param4) : Number(param1);
  453.          this.minScrollPosition = Math.max(param2,0);
  454.          this.maxScrollPosition = Math.max(param3,0);
  455.          _scrollPosition = Math.max(this.minScrollPosition,_scrollPosition);
  456.          _scrollPosition = Math.min(this.maxScrollPosition,_scrollPosition);
  457.          if(this.maxScrollPosition - this.minScrollPosition > 0 && enabled)
  458.          {
  459.             mx_internal::upArrow.enabled = true;
  460.             mx_internal::downArrow.enabled = true;
  461.             mx_internal::scrollTrack.enabled = true;
  462.             addEventListener(MouseEvent.MOUSE_DOWN,scrollTrack_mouseDownHandler);
  463.             addEventListener(MouseEvent.MOUSE_OVER,scrollTrack_mouseOverHandler);
  464.             addEventListener(MouseEvent.MOUSE_OUT,scrollTrack_mouseOutHandler);
  465.             if(!mx_internal::scrollThumb)
  466.             {
  467.                scrollThumb = new ScrollThumb();
  468.                mx_internal::scrollThumb.focusEnabled = false;
  469.                addChildAt(mx_internal::scrollThumb,getChildIndex(mx_internal::downArrow));
  470.                mx_internal::scrollThumb.styleName = new StyleProxy(this,thumbStyleFilters);
  471.                mx_internal::scrollThumb.upSkinName = "thumbUpSkin";
  472.                mx_internal::scrollThumb.overSkinName = "thumbOverSkin";
  473.                mx_internal::scrollThumb.downSkinName = "thumbDownSkin";
  474.                mx_internal::scrollThumb.iconName = "thumbIcon";
  475.                mx_internal::scrollThumb.skinName = "thumbSkin";
  476.             }
  477.             if((_loc5_ = trackHeight < 0 ? Number(0) : Number(Math.round(param1 / (this.maxScrollPosition - this.minScrollPosition + param1) * trackHeight))) < mx_internal::scrollThumb.minHeight)
  478.             {
  479.                if(trackHeight < mx_internal::scrollThumb.minHeight)
  480.                {
  481.                   mx_internal::scrollThumb.visible = false;
  482.                }
  483.                else
  484.                {
  485.                   _loc5_ = mx_internal::scrollThumb.minHeight;
  486.                   mx_internal::scrollThumb.visible = true;
  487.                   mx_internal::scrollThumb.setActualSize(mx_internal::scrollThumb.measuredWidth,mx_internal::scrollThumb.minHeight);
  488.                }
  489.             }
  490.             else
  491.             {
  492.                mx_internal::scrollThumb.visible = true;
  493.                mx_internal::scrollThumb.setActualSize(mx_internal::scrollThumb.measuredWidth,_loc5_);
  494.             }
  495.             mx_internal::scrollThumb.setRange(mx_internal::upArrow.getExplicitOrMeasuredHeight() + 0,mx_internal::virtualHeight - mx_internal::downArrow.getExplicitOrMeasuredHeight() - mx_internal::scrollThumb.height,this.minScrollPosition,this.maxScrollPosition);
  496.             scrollPosition = Math.max(Math.min(scrollPosition,this.maxScrollPosition),this.minScrollPosition);
  497.          }
  498.          else
  499.          {
  500.             mx_internal::upArrow.enabled = false;
  501.             mx_internal::downArrow.enabled = false;
  502.             mx_internal::scrollTrack.enabled = false;
  503.             if(mx_internal::scrollThumb)
  504.             {
  505.                mx_internal::scrollThumb.visible = false;
  506.             }
  507.          }
  508.       }
  509.       
  510.       private function trackScrollTimerHandler(param1:Event) : void
  511.       {
  512.          if(trackScrollRepeatDirection == 1)
  513.          {
  514.             if(mx_internal::scrollThumb.y + mx_internal::scrollThumb.height > trackPosition)
  515.             {
  516.                return;
  517.             }
  518.          }
  519.          if(trackScrollRepeatDirection == -1)
  520.          {
  521.             if(mx_internal::scrollThumb.y < trackPosition)
  522.             {
  523.                return;
  524.             }
  525.          }
  526.          pageScroll(trackScrollRepeatDirection);
  527.          if(trackScrollTimer && trackScrollTimer.repeatCount == 1)
  528.          {
  529.             trackScrollTimer.delay = getStyle("repeatInterval");
  530.             trackScrollTimer.repeatCount = 0;
  531.          }
  532.       }
  533.       
  534.       private function upArrow_buttonDownHandler(param1:FlexEvent) : void
  535.       {
  536.          if(isNaN(mx_internal::oldPosition))
  537.          {
  538.             oldPosition = scrollPosition;
  539.          }
  540.          lineScroll(-1);
  541.       }
  542.       
  543.       public function set pageSize(param1:Number) : void
  544.       {
  545.          _pageSize = param1;
  546.       }
  547.       
  548.       private function get trackY() : Number
  549.       {
  550.          return mx_internal::upArrow.getExplicitOrMeasuredHeight();
  551.       }
  552.       
  553.       private function scrollTrack_mouseOutHandler(param1:MouseEvent) : void
  554.       {
  555.          if(trackScrolling)
  556.          {
  557.             trackScrollTimer.stop();
  558.          }
  559.       }
  560.       
  561.       private function scrollTrack_mouseUpHandler(param1:MouseEvent) : void
  562.       {
  563.          scrollTrack_mouseLeaveHandler(param1);
  564.       }
  565.       
  566.       private function scrollTrack_mouseMoveHandler(param1:MouseEvent) : void
  567.       {
  568.          var _loc2_:Point = null;
  569.          if(trackScrolling)
  570.          {
  571.             _loc2_ = new Point(param1.stageX,param1.stageY);
  572.             _loc2_ = globalToLocal(_loc2_);
  573.             trackPosition = _loc2_.y;
  574.          }
  575.       }
  576.       
  577.       override protected function updateDisplayList(param1:Number, param2:Number) : void
  578.       {
  579.          if(mx_internal::$height == 1)
  580.          {
  581.             return;
  582.          }
  583.          if(!mx_internal::upArrow)
  584.          {
  585.             return;
  586.          }
  587.          super.updateDisplayList(param1,param2);
  588.          if(cacheAsBitmap)
  589.          {
  590.             cacheHeuristic = mx_internal::scrollThumb.cacheHeuristic = false;
  591.          }
  592.          mx_internal::upArrow.setActualSize(mx_internal::upArrow.getExplicitOrMeasuredWidth(),mx_internal::upArrow.getExplicitOrMeasuredHeight());
  593.          if(FlexVersion.compatibilityVersion >= FlexVersion.VERSION_3_0)
  594.          {
  595.             mx_internal::upArrow.move((mx_internal::virtualWidth - mx_internal::upArrow.width) / 2,0);
  596.          }
  597.          else
  598.          {
  599.             mx_internal::upArrow.move(0,0);
  600.          }
  601.          mx_internal::scrollTrack.setActualSize(mx_internal::scrollTrack.getExplicitOrMeasuredWidth(),mx_internal::virtualHeight);
  602.          if(FlexVersion.compatibilityVersion >= FlexVersion.VERSION_3_0)
  603.          {
  604.             mx_internal::scrollTrack.x = (mx_internal::virtualWidth - mx_internal::scrollTrack.width) / 2;
  605.          }
  606.          mx_internal::scrollTrack.y = 0;
  607.          mx_internal::downArrow.setActualSize(mx_internal::downArrow.getExplicitOrMeasuredWidth(),mx_internal::downArrow.getExplicitOrMeasuredHeight());
  608.          if(FlexVersion.compatibilityVersion >= FlexVersion.VERSION_3_0)
  609.          {
  610.             mx_internal::downArrow.move((mx_internal::virtualWidth - mx_internal::downArrow.width) / 2,mx_internal::virtualHeight - mx_internal::downArrow.getExplicitOrMeasuredHeight());
  611.          }
  612.          else
  613.          {
  614.             mx_internal::downArrow.move(0,mx_internal::virtualHeight - mx_internal::downArrow.getExplicitOrMeasuredHeight());
  615.          }
  616.          setScrollProperties(pageSize,minScrollPosition,maxScrollPosition,_pageScrollSize);
  617.          scrollPosition = _scrollPosition;
  618.       }
  619.       
  620.       mx_internal function get pagePlusDetail() : String
  621.       {
  622.          return direction == ScrollBarDirection.VERTICAL ? ScrollEventDetail.PAGE_DOWN : ScrollEventDetail.PAGE_RIGHT;
  623.       }
  624.       
  625.       mx_internal function get virtualWidth() : Number
  626.       {
  627.          return unscaledWidth;
  628.       }
  629.       
  630.       public function set direction(param1:String) : void
  631.       {
  632.          _direction = param1;
  633.          invalidateSize();
  634.          invalidateDisplayList();
  635.          dispatchEvent(new Event("directionChanged"));
  636.       }
  637.       
  638.       [Bindable("directionChanged")]
  639.       public function get direction() : String
  640.       {
  641.          return _direction;
  642.       }
  643.    }
  644. }
  645.